Skip to main content

🎯 Complete System Design Interview Guide — 2025 Edition

Table of Contents​

🧩 Low-Level Design (LLD) Problems​

1️⃣ Core Object-Oriented System Designs​

Focus: Class hierarchy, associations, design patterns, SOLID principles

Must-Practice Systems​

  • Parking Lot System — Multi-floor parking, slot allocation strategies, vehicle types, dynamic pricing
  • Movie Ticket Booking System (BookMyShow) — Show scheduling, seat selection, booking lifecycle, payment processing
  • Library Management System — Catalog management, borrowing/returning, fine calculation, reservation queue
  • Hotel Management System — Room inventory, booking lifecycle, availability calendar, housekeeping integration
  • ATM Machine — Card validation, transaction processing, cash dispensing, account management
  • Vending Machine — State machine implementation, inventory tracking, payment handling, refund logic

Additional Practice​

  • Car Rental System — Fleet management, pricing tiers, damage tracking
  • Restaurant Management System — Table management, order queue, kitchen workflow
  • Inventory Management System — Stock tracking, reorder points, supplier integration
  • Customer Support System — Ticket routing, SLA tracking, escalation logic

2️⃣ Games & Rule-Based Systems​

Focus: Game state management, rule validation, turn-based logic

  • Chess Game — Piece movement validation, check/checkmate detection, castling, en passant
  • Snake and Ladder — Board representation, dice simulation, win condition
  • Tic-Tac-Toe — Win detection algorithms, minimax AI implementation
  • Deck of Cards — Generic card game framework, shuffle algorithms, dealing logic
  • Sudoku Solver — Constraint validation, backtracking algorithm
  • Battleship Game — Grid management, hit detection, game state tracking

3️⃣ Caching, Performance & Rate Limiting​

Focus: Data structures, algorithms, optimization techniques

  • LRU Cache — HashMap + Doubly Linked List, O(1) operations
  • LFU Cache — Frequency-based eviction, min-heap optimization
  • Rate Limiter — Token bucket, sliding window log, fixed window counter
  • Logging Framework — Log levels, appenders (file, console, remote), async processing, rotation
  • Circuit Breaker — Failure detection, half-open state, fallback mechanisms

4️⃣ Communication & Notification Systems​

Focus: Event-driven architecture, observer pattern, pub-sub

  • Notification System — Multi-channel delivery (email, SMS, push), priority queue, retry logic
  • Chat Application — Message persistence, delivery status, read receipts, group chat
  • Collaborative Text Editor — Operational transformation, conflict resolution, cursor synchronization
  • Comment System — Nested comments, voting, threading, moderation

5️⃣ Transaction & E-Commerce Systems​

Focus: State machines, payment flows, inventory management

  • Shopping Cart — Product catalog, cart operations, discount engine, checkout flow
  • Splitwise/Expense Sharing — Group management, debt calculation, settlement optimization
  • Ride Booking System (Uber/Ola) — Driver-rider matching, fare calculation, trip lifecycle
  • Payment Gateway — Transaction states, idempotency, webhook handling, retry logic
  • Order Management System — Order states, fulfillment workflow, cancellation/refund handling

6️⃣ Scheduling & Resource Allocation​

Focus: Time slot management, conflict resolution, optimization algorithms

  • Meeting Room Booking — Calendar integration, conflict detection, recurring meetings
  • Task Scheduler — Dependency graphs, priority queues, deadline management
  • Elevator System — SCAN/LOOK algorithms, direction optimization, load balancing
  • Traffic Signal Controller — State machines, timing optimization, emergency vehicle priority
  • Parking Slot Allocation — Nearest slot algorithm, handicap priority, vehicle size matching

7️⃣ Data Organization & Hierarchical Systems​

Focus: Tree structures, composite pattern, CRUD operations

  • File System — Directory tree, permissions (UNIX-style), symbolic links
  • Stack Overflow Clone — Question/Answer model, tagging, voting, reputation system
  • Social Media Feed — Post aggregation, comment threads, engagement metrics
  • Directory Structure — Composite pattern, visitor pattern for operations
  • Menu System — Nested categories, item variations, pricing rules

8️⃣ Design Patterns in Practice​

Focus: Real-world pattern applications

  • Factory Pattern — Payment processor factory, vehicle factory
  • Strategy Pattern — Sorting algorithms, pricing strategies, validation rules
  • Observer Pattern — Event notification system, stock price monitoring
  • Decorator Pattern — Pizza toppings, coffee add-ons, IO streams
  • Command Pattern — Undo/redo functionality, macro recording
  • Singleton Pattern — Configuration manager, logger, database connection pool

🏗️ High-Level Design (HLD) Problems​

🌱 Tier 1: Foundation Systems (Start Here)​

Focus: Core scalability concepts, basic distributed systems

  • URL Shortener (bit.ly) — Hash generation, collision handling, analytics
  • Pastebin — Content storage, expiration, syntax highlighting
  • Key-Value Store — Consistent hashing, replication, eventual consistency
  • Rate Limiter — Distributed rate limiting, Redis-based implementation
  • File Hosting Service — Chunking, deduplication, metadata storage

📱 Tier 2: Social Media & Content Platforms​

Focus: Feed generation, ranking algorithms, caching strategies

Core Social Networks​

  • Twitter/X — Tweet ingestion, timeline generation, trending topics, @ mentions
  • Instagram — Photo/video storage, feed ranking, stories (ephemeral content), explore page
  • Facebook News Feed — Friend graph, edge rank algorithm, content mixing
  • LinkedIn — Professional network, job recommendations, connection degrees
  • TikTok/Reels — Short video recommendations, viral detection, creator analytics

Community Platforms​

  • Reddit — Subreddit architecture, voting system, hot/top algorithms
  • Medium — Article publishing, claps system, reading time estimation
  • Discord — Server/channel hierarchy, role permissions, voice channels

🎬 Tier 2: Streaming & Media Systems​

Focus: CDN, adaptive bitrate, recommendation engines

  • YouTube — Video transcoding, CDN distribution, watch later, subscriptions
  • Netflix — Adaptive streaming (HLS/DASH), personalization, continue watching
  • Spotify — Audio streaming, playlist generation, collaborative filtering
  • Twitch — Live streaming, chat integration, low-latency delivery
  • Podcast Platform — RSS feed aggregation, download management, playback sync

🚗 Tier 2: On-Demand & Real-Time Systems​

Focus: Geospatial indexing, real-time matching, ETA calculation

  • Uber/Lyft — Driver-rider matching, surge pricing, trip routing, driver location updates
  • Food Delivery (DoorDash/Zomato) — Restaurant inventory, delivery assignment, order tracking
  • Airbnb — Listing search, availability calendar, booking workflow, review system
  • Hotel Booking (Booking.com) — Inventory management, price comparison, cancellation policies

🛍️ Tier 2: E-Commerce & Marketplace​

Focus: Inventory consistency, checkout flow, recommendation systems

  • Amazon — Product catalog, search ranking, cart management, order fulfillment
  • eBay — Auction system, bidding logic, seller ratings
  • Shopify — Multi-tenant architecture, payment processing, inventory sync
  • Payment Gateway (Stripe/Razorpay) — Fraud detection, PCI compliance, ledger consistency
  • Coupon/Promo System — Validation rules, usage limits, stacking logic

📂 Tier 3: Storage & Collaboration Systems​

Focus: Consistency models, conflict resolution, versioning

  • Dropbox/Google Drive — File sync, delta updates, version history, sharing permissions
  • Google Docs — Real-time collaboration, operational transformation, cursor tracking
  • Notion — Block-based editor, nested pages, database views
  • GitHub — Version control, pull requests, code review, CI/CD integration
  • Distributed File System — HDFS-like architecture, replication, fault tolerance

💬 Tier 3: Communication Platforms​

Focus: Real-time protocols, message persistence, encryption

  • WhatsApp/Telegram — End-to-end encryption, message delivery guarantees, media sharing
  • Slack — Workspace isolation, channel threading, search indexing
  • Zoom/Teams — WebRTC signaling, media servers, screen sharing, recording
  • Email Service — SMTP/IMAP, spam filtering, attachment handling
  • Video Conferencing — SFU vs MCU, bandwidth adaptation, recording

🔍 Tier 3: Search & Discovery​

Focus: Indexing, ranking, autocomplete, geospatial queries

  • Google Search — Web crawling, inverted index, PageRank, freshness
  • Search Autocomplete — Trie data structure, query suggestion ranking
  • Yelp/Foursquare — Geohash/Quadtree, proximity search, rating aggregation
  • E-Commerce Search — Faceted search, filters, personalized ranking
  • Type-ahead Search — Debouncing, caching, popularity signals

⚙️ Tier 4: Infrastructure & Distributed Components​

Focus: Reliability, fault tolerance, consensus algorithms

Core Infrastructure​

  • Load Balancer — Health checks, algorithms (round-robin, least connections, consistent hashing)
  • API Gateway — Authentication, rate limiting, request routing, API versioning
  • Service Mesh — Sidecar pattern, circuit breakers, observability
  • Distributed Cache (Redis/Memcached) — Cache invalidation, eviction policies, replication

Messaging & Streaming​

  • Message Queue (Kafka/RabbitMQ) — Pub-sub vs queue, ordering guarantees, partitioning
  • Event Streaming Platform — Event sourcing, CQRS, replay capability
  • Webhook Delivery System — Retry logic, dead letter queue, signature verification

Coordination Services​

  • Distributed Lock — Redlock algorithm, lease management
  • Leader Election — Raft/Paxos consensus, split-brain prevention
  • Service Discovery — Health checking, DNS-based vs client-side
  • Configuration Management — Dynamic updates, versioning, rollback

📊 Tier 4: Analytics, Monitoring & Observability​

Focus: Time-series data, log aggregation, real-time processing

  • Metrics Monitoring (Prometheus/Datadog) — Time-series DB, aggregation, alerting
  • Distributed Logging (ELK Stack) — Log collection, indexing, search, retention
  • Distributed Tracing (Jaeger) — Span context propagation, sampling strategies
  • Analytics Platform — Lambda architecture, batch + stream processing
  • Ad Click Tracker — Fraud detection, real-time counting, attribution
  • A/B Testing Platform — Traffic splitting, statistical significance, metrics tracking

🎯 Tier 5: Specialized & Advanced Systems​

Focus: Complex coordination, low-latency, domain-specific challenges

High-Performance Systems​

  • Stock Exchange — Order matching engine, low-latency networking, market data feed
  • Trading Platform — Order book, matching algorithms (FIFO, pro-rata), settlement
  • Gaming Backend — Matchmaking, anti-cheat, leaderboards, game state sync

Content & Creator Platforms​

  • Online Code Editor (LeetCode/CodePen) — Sandboxing, code execution, real-time collaboration
  • Live Streaming Platform — RTMP ingestion, transcoding, CDN, chat
  • Content Recommendation — Collaborative filtering, matrix factorization, deep learning

Ticketing & Booking​

  • Ticketmaster — Seat locking, inventory consistency, surge handling, bot prevention
  • Flight Booking — Multi-leg search, fare rules, seat selection, cancellation
  • Event Management — RSVP tracking, check-in, waitlist management

Specialized Infrastructure​

  • Web Crawler — Politeness, robots.txt, deduplication, distributed crawling
  • Global Counter — Distributed counting, conflict resolution, eventual consistency
  • Rate Limiting as a Service — Multi-tenant, configurable rules, analytics
  • Feature Flag System — Dynamic configuration, targeting rules, gradual rollout

🎨 Essential Design Patterns Reference​

PatternPrimary Use CasesLLD Examples
SingletonLogger, Configuration Manager, Connection PoolLogging System, Database Manager
FactoryObject creation without specifying exact classVehicle Factory, Payment Processor
Abstract FactoryFamilies of related objectsUI Toolkit (Windows/Mac themes)
BuilderComplex object constructionOrder Builder, Query Builder
PrototypeCloning expensive objectsDocument templates
StrategyInterchangeable algorithmsPricing Strategy, Sort Strategy
ObserverEvent notification, pub-subNotification System, Stock Ticker
CommandEncapsulate requests, undo/redoText Editor, Transaction System
StateObject behavior changes with stateVending Machine, ATM, Order Lifecycle
DecoratorAdd responsibilities dynamicallyStream wrappers, Pizza toppings
AdapterInterface compatibilityLegacy system integration
FacadeSimplified interface to subsystemAPI wrapper, Library interface
CompositeTree structures, part-whole hierarchyFile System, Menu System
ProxyControl access, lazy loadingImage Proxy, Access Control
Chain of ResponsibilitySequential request handlingApproval workflow, Logging levels
Template MethodAlgorithm skeleton with customizationData parser, Game framework

⚙️ Core HLD Concepts Mastery​

🎯 Scalability & Performance​

  • Horizontal vs Vertical Scaling — When to scale out vs up
  • Database Sharding — Hash-based, range-based, geo-based
  • Partitioning Strategies — Consistent hashing, virtual nodes
  • Replication — Master-slave, multi-master, quorum-based
  • Caching Strategies — Cache-aside, write-through, write-back, write-around
  • CDN Architecture — Edge locations, cache invalidation, origin shield

🔄 Load Balancing & Routing​

  • Algorithms — Round robin, least connections, weighted, IP hash
  • Layer 4 vs Layer 7 — TCP vs HTTP load balancing
  • Health Checks — Active vs passive, failure detection
  • Session Persistence — Sticky sessions, session replication
  • Global Server Load Balancing — GeoDNS, latency-based routing

💾 Database Design​

  • SQL vs NoSQL — ACID vs BASE, use case selection
  • Normalization — 1NF, 2NF, 3NF, denormalization trade-offs
  • Indexing — B-tree, hash, bitmap, composite indexes
  • Query Optimization — Explain plans, covering indexes
  • Transactions — Isolation levels, deadlock prevention
  • Database Scaling — Read replicas, sharding, federation

🏛️ Architectural Patterns​

  • Microservices — Service boundaries, API contracts, data ownership
  • Event-Driven Architecture — Event sourcing, CQRS, saga pattern
  • Serverless — Function-as-a-Service, cold starts, stateless design
  • Service Mesh — Istio/Linkerd, observability, traffic management
  • API Gateway Pattern — Authentication, rate limiting, transformation

📬 Messaging & Queues​

  • Message Queue — Point-to-point, guaranteed delivery
  • Pub-Sub — Topic-based, fan-out, message filtering
  • Kafka Architecture — Topics, partitions, consumer groups, retention
  • Message Ordering — Partition keys, sequence numbers
  • Exactly-Once Semantics — Idempotency, deduplication

🔐 Security & Reliability​

  • Authentication — JWT, OAuth 2.0, session management
  • Authorization — RBAC, ABAC, policy enforcement
  • Rate Limiting — Token bucket, leaky bucket, sliding window
  • Circuit Breaker — Failure detection, fallback strategies
  • Retry Strategies — Exponential backoff, jitter, idempotency
  • Distributed Transactions — 2PC, Saga pattern, compensation

🌐 Distributed Systems​

  • CAP Theorem — Consistency, availability, partition tolerance trade-offs
  • Consistency Models — Strong, eventual, causal, read-your-writes
  • Consensus Algorithms — Raft, Paxos, leader election
  • Distributed Locks — Redlock, Chubby, ZooKeeper
  • Clock Synchronization — NTP, vector clocks, Lamport timestamps
  • Split-Brain Prevention — Quorum, fencing tokens

📈 Monitoring & Observability​

  • Metrics — RED (Rate, Errors, Duration), USE (Utilization, Saturation, Errors)
  • Logging — Structured logging, log levels, sampling
  • Tracing — Distributed tracing, span context, sampling
  • Alerting — Thresholds, anomaly detection, alert fatigue prevention
  • SLIs/SLOs/SLAs — Service level objectives, error budgets

🗺️ Interview Preparation Roadmap​

📅 Phase 1: Foundations (Weeks 1-3)​

Goal: Master OOP principles and design patterns

  • ✅ Study SOLID principles with real examples
  • ✅ Learn 8-10 core design patterns (with code)
  • ✅ Practice UML diagrams (class, sequence, state)
  • ✅ Understand composition vs inheritance
  • ✅ Study interface segregation and dependency injection

Practice:

  • Implement 3-4 design patterns from scratch
  • Draw class diagrams for familiar systems

📅 Phase 2: Low-Level Design (Weeks 4-7)​

Goal: Build muscle memory for LLD interviews

Week 4-5: Core Systems

  • Parking Lot System
  • Library Management
  • ATM Machine
  • Vending Machine

Week 6-7: Advanced Systems

  • Movie Ticket Booking
  • Hotel Management
  • Chess Game
  • LRU/LFU Cache

Daily Routine:

  • Design 1 system completely (2-3 hours)
  • Code critical classes (1 hour)
  • Review and refactor (30 mins)

Tips:

  • Start with requirements gathering
  • Draw class diagrams before coding
  • Focus on extensibility
  • Handle edge cases
  • Write clean, production-ready code

📅 Phase 3: HLD Fundamentals (Weeks 8-10)​

Goal: Learn scalability and distributed systems basics

Week 8: Foundation Concepts

  • Vertical vs horizontal scaling
  • Load balancing algorithms
  • Caching strategies (CDN, in-memory)
  • Database replication and sharding

Week 9: Simple Systems

  • URL Shortener (complete deep dive)
  • Pastebin
  • Rate Limiter
  • Key-Value Store

Week 10: Database & Storage

  • SQL vs NoSQL selection criteria
  • Indexing strategies
  • CAP theorem applications
  • File storage systems

Study Method:

  • Read system design primers (System Design Interview books)
  • Watch architecture talks on YouTube
  • Study real system architectures (Netflix, Uber tech blogs)

📅 Phase 4: Advanced HLD (Weeks 11-14)​

Goal: Handle complex distributed systems

Week 11: Social Media

  • Twitter/Instagram (focus on feed generation)
  • Understand fan-out approaches
  • Timeline generation algorithms

Week 12: Real-Time Systems

  • Uber (location tracking, matching)
  • WhatsApp (message delivery)
  • Websockets vs long polling

Week 13: Streaming & E-Commerce

  • Netflix (video delivery, CDN)
  • Amazon (product search, cart)

Week 14: Infrastructure

  • Message queues (Kafka architecture)
  • Service mesh concepts
  • Distributed caching

Practice:

  • Design 2-3 systems per week
  • Time yourself (45 mins per design)
  • Focus on trade-offs and bottlenecks

📅 Phase 5: Mock Interviews & Refinement (Weeks 15-16)​

Goal: Perfect interview communication and timing

Week 15:

  • 3-4 LLD mocks with peers/mentors
  • 3-4 HLD mocks
  • Record yourself and review

Week 16:

  • Focus on weak areas identified in mocks
  • Practice articulating trade-offs clearly
  • Review common follow-up questions

Mock Interview Checklist:

  • ✅ Clarify requirements (5 mins)
  • ✅ Scope the problem (functional & non-functional)
  • ✅ Propose high-level approach (5 mins)
  • ✅ Deep dive into components (20 mins)
  • ✅ Discuss trade-offs (5 mins)
  • ✅ Handle scale calculations (5 mins)
  • ✅ Answer follow-ups (10 mins)

🎯 Interview Day Strategy​

LLD Interview Approach (45-60 mins)​

  1. Requirements Clarification (5-7 mins)

    • Ask about functional requirements
    • Identify non-functional requirements (extensibility, maintainability)
    • Clarify ambiguities
    • Agree on scope

  2. Core Entities & Relationships (10 mins)

    • List main classes/entities
    • Define relationships (composition, inheritance)
    • Quick class diagram sketch

  3. Design Patterns & SOLID (5 mins)

    • Identify applicable patterns
    • Explain pattern choices
    • Mention SOLID principles being followed

  4. Detailed Design (15-20 mins)

    • Expand critical classes
    • Define key methods and attributes
    • Handle main use cases
    • Draw sequence diagrams if needed

  5. Code Critical Parts (10-15 mins)

    • Implement 1-2 complex methods
    • Show clean code practices
    • Handle edge cases

  6. Discussion & Extensions (5 mins)

    • Discuss extensibility
    • Handle interviewer's modifications
    • Talk about testing approach

HLD Interview Approach (45-60 mins)​

  1. Requirements & Scope (5-8 mins)

    • Functional requirements (what features?)
    • Non-functional requirements (scale, latency, consistency)
    • Traffic estimates (DAU, QPS, storage)
    • Success metrics

  2. Capacity Estimation (3-5 mins)

    • Quick back-of-envelope calculations
    • Storage estimates
    • Bandwidth requirements
    • QPS calculations

  3. High-Level Design (8-10 mins)

    • Draw box diagram
    • Identify major components
    • Show data flow
    • Explain at 30,000 ft level

  4. Deep Dive (20-25 mins)

    • Drill into critical components
    • Database schema design
    • API design
    • Discuss scaling strategies
    • Address bottlenecks

  5. Trade-offs & Alternatives (5 mins)

    • Compare different approaches
    • Explain chosen trade-offs
    • Discuss what you'd do differently at different scales

  6. Follow-ups (5 mins)

    • Monitoring and alerting
    • Failure scenarios
    • Security considerations
    • Future optimizations

📚 Essential Resources​

Books​

  • Designing Data-Intensive Applications by Martin Kleppmann (MUST READ)
  • System Design Interview Volume 1 & 2 by Alex Xu
  • Head First Design Patterns by Freeman & Robson
  • Clean Code by Robert C. Martin
  • Domain-Driven Design by Eric Evans

Online Resources​

  • System Design Primer (GitHub)
  • Grokking the System Design Interview (Educative.io)
  • ByteByteGo Newsletter (Alex Xu)
  • Company engineering blogs: Netflix, Uber, Airbnb, LinkedIn

YouTube Channels​

  • Gaurav Sen (System Design)
  • Tech Dummies Narendra L
  • ByteByteGo
  • System Design Interview
  • Hussein Nasser

Practice Platforms​

  • LeetCode (for LLD coding)
  • Pramp (mock interviews)
  • Exponent
  • Hello Interview

💡 Final Tips for Success​

LLD Tips​

  • ✨ Always start with requirements gathering
  • ✨ Think extensibility, not just functionality
  • ✨ Use design patterns judiciously (don't over-engineer)
  • ✨ Write self-documenting code
  • ✨ Handle edge cases explicitly
  • ✨ Be ready to modify your design based on new requirements

HLD Tips​

  • ✨ Think aloud — Let interviewer follow your thought process
  • ✨ Start simple, then scale — Don't jump to distributed systems immediately
  • ✨ Numbers matter — Do rough calculations to justify decisions
  • ✨ Trade-offs are key — Everything is a trade-off; articulate them clearly
  • ✨ No silver bullets — Acknowledge limitations of your approach
  • ✨ Ask clarifying questions — Better to ask than assume
  • ✨ Focus on breadth first — Cover all components before deep-diving
  • ✨ Be pragmatic — Real-world constraints matter (cost, team size, timeline)

Communication Tips​

  • 🗣️ Structure your thoughts before speaking
  • 🗣️ Use diagrams liberally
  • 🗣️ Admit when you don't know something
  • 🗣️ Ask for hints if stuck (shows humility)
  • 🗣️ Summarize decisions at key points
  • 🗣️ Engage with interviewer — it's a conversation, not a presentation

🎓 Common Pitfalls to Avoid​

LLD Mistakes​

  • ❌ Jumping to code before design
  • ❌ Creating god classes
  • ❌ Ignoring SOLID principles
  • ❌ Not considering extensibility
  • ❌ Poor naming conventions
  • ❌ Overcomplicating with unnecessary patterns

HLD Mistakes​

  • ❌ Not clarifying requirements
  • ❌ Ignoring scale/traffic numbers
  • ❌ Over-engineering for current scale
  • ❌ Not discussing trade-offs
  • ❌ Ignoring single points of failure
  • ❌ Vague hand-wavy explanations
  • ❌ Not considering data consistency models
  • ❌ Forgetting about monitoring/alerting

✅ Pre-Interview Checklist​

One Week Before:

  • Review all practiced systems
  • Skim design patterns reference
  • Practice whiteboard drawing
  • Review CAP theorem, consistency models
  • Brush up on back-of-envelope calculations

One Day Before:

  • Light review (no new topics)
  • Get good sleep
  • Prepare questions for interviewer
  • Test setup (pen, paper, laptop if virtual)

Interview Day:

  • Arrive/log in 10 mins early
  • Have water nearby
  • Keep calm and think before speaking
  • Remember: interviewer wants you to succeed!

🎉 You've Got This!​

System design interviews test your engineering maturity, problem-solving approach, and communication skills more than perfect solutions. There's rarely one "correct" answer. Show your thinking, justify your decisions, and engage in thoughtful discussion. Good luck! 🚀

Last Updated: October 2025